home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 2 / Atari Mega Archive CD - Volume 2.iso / minix / up1510b.tgz / up1510b / src / kernel / stdmp.c < prev    next >
C/C++ Source or Header  |  1990-07-23  |  6KB  |  248 lines
  1. #if (CHIP == M68000)
  2. /* This file contains some dumping routines for debugging. */
  3.  
  4. #include "kernel.h"
  5. #include <minix/callnr.h>
  6. #include <minix/com.h>
  7. #include "tty.h"
  8. #include "proc.h"
  9.  
  10. void prname();
  11. void mem_dmp();
  12.  
  13. #undef    NEEDED
  14. #undef    TTYDMP
  15.  
  16. #define NSIZE 20
  17. phys_bytes aout[NR_PROCS];    /* pointers to the program names */
  18. char nbuff[NSIZE+1];
  19. char *vargv;
  20.  
  21. /*===========================================================================*
  22.  *                DEBUG routines here                 * 
  23.  *===========================================================================*/
  24. PUBLIC void p_dmp()
  25. {
  26. /* Proc table dump */
  27.  
  28.   register struct proc *rp;
  29.   char *np;
  30.   vir_clicks base, limit, first, last;
  31.   phys_bytes ltmp, dst;
  32.   int index;
  33.   int i;
  34.   char *cp;
  35.  
  36.   printf(
  37.   "\r\nproc    pid     pc     sp  splow flag  user    sys  base  limit  recv   command\r\n");
  38.  
  39.   dst = umap(proc_addr(SYSTASK), D, (vir_bytes)nbuff, (vir_bytes)NSIZE);
  40.  
  41.   for (rp = &proc[0]; rp < &proc[NR_PROCS+NR_TASKS]; rp++)  {
  42.     if (rp->p_flags & P_SLOT_FREE) continue;
  43.     first = rp->p_map[T].mem_phys;
  44.     last = rp->p_map[S].mem_phys + rp->p_map[S].mem_len;
  45.     ltmp = ((long) first << CLICK_SHIFT) + 512L;
  46.     base = (vir_clicks) (ltmp/1024L);
  47.     ltmp = (((long) last << CLICK_SHIFT) + 512L);
  48.     limit = (vir_clicks) (ltmp/1024L);
  49.     prname((int)(rp - proc));
  50.     printf(" %4d %6X %6X %6X %4x %5D %6D  %4dK %4dK  ",
  51.         rp->p_pid, (long)rp->p_reg.pc,
  52.         (long)rp->p_reg.sp, (long)rp->p_splow,
  53.         rp->p_flags, rp->user_time, rp->sys_time,
  54.         base, limit);
  55.     if (rp->p_flags == 0)
  56.         printf("      ");
  57.     else
  58.         prname(NR_TASKS + rp->p_getfrom);
  59.  
  60.     /* Fetch the command string from the user process. */
  61.     index = (int)(rp - proc) - NR_TASKS;
  62.     if (index > LOW_USER && aout[index] != 0) {
  63.         phys_copy(aout[index], dst, (long) NSIZE);
  64.         nbuff[NSIZE] = 0;
  65.         for (np = &nbuff[0]; np < &nbuff[NSIZE]; np++)
  66.             if (*np <= ' ' || *np >= 0177) *np = 0;
  67.         if (index == LOW_USER + 1)
  68.             cp = "/bin/sh";
  69.         else
  70.             cp = nbuff;
  71.         for(i=0;i<100;i++) 
  72.             if(cp[i] == '\0')
  73.                 break;
  74.         if(i > 6)
  75.             printf("\r\n\t");
  76.         printf("%s", cp);
  77.     }
  78.     printf("\r\n");
  79.   }
  80. #ifdef NEEDED
  81.   printf("\r\nproc    callq sendlk mesbuf from nready pend\r\n");
  82.   for (rp = &proc[0]; rp < &proc[NR_PROCS+NR_TASKS]; rp++)  {
  83.     if (rp->p_flags & P_SLOT_FREE) continue;
  84.     prname((int)(rp - proc));
  85.     printf(" %6X %6X %6X %4d %6X %4d\r\n",
  86.         rp->p_callerq,
  87.         rp->p_sendlink,
  88.         rp->p_messbuf,
  89.         rp->p_getfrom,
  90.         rp->p_nextready,
  91.         rp->p_pending
  92.     );
  93.   }
  94.   for (index = 0; index < NQ; index++) {
  95.     printf("q=%d: ", index);
  96.     for (rp = rdy_head[index]; rp != NIL_PROC; rp = rp->p_nextready)
  97.         printf(" %d", (int)(rp-proc));
  98.     printf("\r\n");
  99.   }
  100. #endif NEEDED
  101.   printf("\r\n");
  102. }
  103.  
  104.  
  105. PUBLIC void map_dmp()
  106. {
  107.   register struct proc *rp;
  108.   vir_clicks base, limit, first, last;
  109.   phys_bytes ltmp;
  110.  
  111.   printf("\r\nPROC   --TEXT---  --DATA---  --STACK-- SHADOW FLIP P BASE  SIZE\r\n");
  112.   for (rp = &proc[NR_TASKS]; rp < &proc[NR_TASKS+NR_PROCS]; rp++)  {
  113.     if (rp->p_flags & P_SLOT_FREE) continue;
  114.     first = rp->p_map[T].mem_phys;
  115.     last = rp->p_map[S].mem_phys + rp->p_map[S].mem_len;
  116.     ltmp = ((long) first << CLICK_SHIFT) + 512L;
  117.     base = (vir_clicks) (ltmp/1024L);
  118.     ltmp = (((long) (last-first) << CLICK_SHIFT) + 512L);
  119.     limit = (vir_clicks) (ltmp/1024L);
  120.     prname((int)(rp-proc));
  121.     printf(" %4x %4x  %4x %4x  %4x %4x   %4x %4d %d %4dK %4dK\r\n", 
  122.         rp->p_map[T].mem_phys, rp->p_map[T].mem_len,
  123.         rp->p_map[D].mem_phys, rp->p_map[D].mem_len,
  124.         rp->p_map[S].mem_phys, rp->p_map[S].mem_len,
  125.         rp->p_shadow, rp->p_nflips, rp->p_physio, base, limit);
  126.   }
  127. }
  128.  
  129.  
  130. PUBLIC void prname(i)
  131. int i;
  132. {
  133.   if (i == ANY+NR_TASKS)
  134.     printf("ANY   ");
  135.   else if (i >= 0 && i <= NR_TASKS+2)
  136.     printf("%s", tasktab[i].name);
  137.   else
  138.     printf("%4d  ", i-NR_TASKS);
  139. }
  140.  
  141. PUBLIC void set_name(proc_nr, ptr)
  142. int proc_nr;
  143. char *ptr;
  144. {
  145. /* When an EXEC call is done, the kernel is told about the stack pointer.
  146.  * It uses the stack pointer to find the command line, for dumping
  147.  * purposes.
  148.  */
  149.  
  150.   phys_bytes src, dst;
  151.  
  152.   if (ptr == (char *) 0) {
  153.     aout[proc_nr] = (phys_bytes) 0;
  154.     return;
  155.   }
  156.  
  157.   src = umap(
  158.     proc_addr(proc_nr),
  159.     D,
  160.     (vir_bytes)(ptr + sizeof(char *)),
  161.     (vir_bytes)sizeof(char *)
  162.   );
  163.   if (src == 0)
  164.     return;
  165.   dst = umap(
  166.     proc_addr(SYSTASK),
  167.     D,
  168.     (vir_bytes)&vargv,
  169.     (vir_bytes)sizeof(char *)
  170.   );
  171.   phys_copy(src, dst, (phys_bytes)sizeof(char *));
  172.   aout[proc_nr] = umap(
  173.     proc_addr(proc_nr),
  174.     D,
  175.     (vir_bytes)vargv,
  176.     (vir_bytes)NSIZE
  177.   );
  178. }
  179.  
  180. PUBLIC void reg_dmp(rp, dummy)
  181. register struct proc *rp;
  182. {
  183.     register int i;
  184.     static char *regs[NR_REGS] = {
  185.         "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
  186.         "a0", "a1", "a2", "a3", "a4", "a5", "a6"
  187.     }; 
  188.     reg_t *regptr = (reg_t *) &rp->p_reg;
  189.     
  190.     printf("reg = %08X, ", rp);
  191.     printf("ksp = %08X\r\n", (long)&dummy);
  192.     printf(" pc = %08X, ", rp->p_reg.pc);
  193.     printf(" sr =     %04x, ", rp->p_reg.psw);
  194.     printf("trp =       %2x\r\n", rp->p_trap);
  195.     for (i = 0; i < NR_REGS; i++)
  196.         printf("%3s = %08X%s",
  197.             regs[i],
  198.             *regptr++,
  199.             (i&3) == 3 ? "\r\n" : ", "
  200.         );
  201.     printf(" a7 = %08X\r\n", rp->p_reg.sp);
  202.     mem_dmp((char *)(((long)rp->p_reg.pc & ~31L) - 96), 128);
  203.     mem_dmp((char *)(((long)rp->p_reg.sp & ~31L) - 32), 256);
  204. }
  205.  
  206. PUBLIC void mem_dmp(adr, len)
  207. char *adr;
  208. {
  209.     register i;
  210.     register long *p;
  211.  
  212.     for (i = 0, p = (long *)adr; i < len; i += 4) {
  213.         if ((i & 31) == 0)
  214.             printf("\r\n%X:", p);
  215.         printf(" %8X", *p++);
  216.     }
  217.     printf("\r\n");
  218. }
  219.  
  220. #ifdef TTYDMP
  221. PUBLIC void tty_dmp()
  222. {
  223.    struct tty_struct *tp;
  224.    int i;
  225.  
  226.    printf("output_done = %d\r\n", output_done);
  227.    printf("flush_flag = %d\r\n", flush_flag);
  228.  
  229.    printf("tty_buf_count = %d, tty_buf_max = %d\r\n",
  230.        tty_buf_count(tty_driver_buf), tty_buf_max(tty_driver_buf));
  231.  
  232.    for (i = 0; i < NR_CONS + NR_RS_LINES; i++)
  233.    {
  234.     tp = &tty_struct[i]; 
  235.     printf("line %d; incount = %d, inleft = %d, outleft = %d\n",
  236.          i, tp->tty_incount, tp->tty_inleft, tp->tty_outleft);
  237.     if (tp->tty_busy) printf("busy\r\n"); else printf("not busy\r\n");
  238.     if (tp->tty_inhibited) printf("inhibited\r\n");
  239.     else printf("not inhibited\r\n");
  240.     if (tp->tty_waiting)
  241.         if (tp->tty_waiting == COMPLETED) printf("completed\r\n");
  242.         else printf("waiting\r\n");
  243.     else printf("not waiting\r\n");
  244.    }
  245. }
  246. #endif
  247. #endif
  248.